import { streamText } from 'ai';
import { createDeepSeek } from '@ai-sdk/deepseek';
import { getGeocode, getCurrentWeather, calculator, getTime } from './agent-tools';
import { fromTemplate } from './agent-FromTemplate';

// 创建 DeepSeek 客户端
const deepseek = createDeepSeek({
  apiKey: process.env.AI_GATEWAY_API_KEY
});

// 定义工具集合
const tools = {
  getGeocode,
  getCurrentWeather,
  calculator,
  getTime
};

// Agent 聊天接口：处理需要工具调用的问题
export async function POST(req: Request) {
  try {
    const { messages } = await req.json();

    console.log('🤖 Agent 模式收到请求');

    // 使用 streamText 并启用工具调用
    const result = await streamText({
      model: deepseek('deepseek-chat'),
      messages: messages,
      system: fromTemplate,
      tools: tools,
    });

    // 转换为标准的流式格式
    const encoder = new TextEncoder();
    const readableStream = new ReadableStream({
      async start(controller) {
        try {
          // 使用 fullStream 来获取所有类型的事件（文本、工具调用、工具结果）
          for await (const chunk of result.fullStream) {
            let chunkText = "";

            // 处理不同类型的 chunk
            if (chunk.type === 'text-delta') {
              // 文本增量：直接输出
              const textChunk = chunk as { type: 'text-delta'; text: string };
              chunkText = textChunk.text || '';
            } else if (chunk.type === 'tool-call') {
              // 工具调用：显示调用信息
              const toolCallChunk = chunk as { type: 'tool-call'; toolName: string; input?: unknown; args?: unknown };
              const toolName = toolCallChunk.toolName;
              const toolArgs = JSON.stringify(toolCallChunk.input || toolCallChunk.args, null, 2);
              chunkText = `\n\n🔧 **调用工具**: \`${toolName}\`\n\`\`\`json\n${toolArgs}\n\`\`\`\n`;
              console.log(`🔧 调用工具: ${toolName}`, toolCallChunk.input || toolCallChunk.args);
            } else if (chunk.type === 'tool-result') {
              // 工具结果：显示返回值
              const toolResultChunk = chunk as { type: 'tool-result'; toolName: string; output?: unknown; result?: unknown };
              const toolName = toolResultChunk.toolName;
              const toolResult = toolResultChunk.output || toolResultChunk.result;

              // 格式化工具结果
              let formattedResult = toolResult;
              if (typeof toolResult === 'object') {
                formattedResult = JSON.stringify(toolResult, null, 2);
              } else if (typeof toolResult === 'string' && toolResult.length > 300) {
                formattedResult = toolResult.substring(0, 300) + '...';
              }

              chunkText = `\n✅ **工具 \`${toolName}\` 返回**:\n\`\`\`json\n${formattedResult}\n\`\`\`\n\n`;
              console.log(`✅ 工具 ${toolName} 返回:`, toolResult);
            }

            // 将构建好的文本块编码并加入流
            if (chunkText) {
              const data = `0:${JSON.stringify(chunkText)}\n`;
              controller.enqueue(encoder.encode(data));
            }
          }

          controller.close();
        } catch (error) {
          console.error('Agent 流式输出失败:', error);
          const errorText = `\n\n❌ Agent 处理失败: ${error instanceof Error ? error.message : String(error)}`;
          const errorData = `0:${JSON.stringify(errorText)}\n`;
          controller.enqueue(encoder.encode(errorData));
          controller.close();
        }
      },
    });

    return new Response(readableStream, {
      headers: {
        'Content-Type': 'text/plain; charset=utf-8',
        'X-Vercel-AI-Data-Stream': 'v1',
      },
    });
  } catch (error) {
    console.error('Agent 处理失败:', error);
    return new Response(JSON.stringify({
      error: 'Agent 服务器处理失败',
      details: error instanceof Error ? error.message : String(error)
    }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' },
    });
  }
}
